home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / kms20src.lha / KMSC / access.c next >
C/C++ Source or Header  |  1994-10-14  |  11KB  |  435 lines
  1. /**********************************
  2.  *              KMS               *
  3.  **********************************
  4.  *  ©1992 by BlackMagic Software  *
  5.  **********************************
  6.  *                                *
  7.  **********************************/
  8.  
  9. #include <KMS/KMS.h>
  10.  
  11. Prototype UBYTE CheckAccess(struct AreaNode *);
  12. Prototype struct ACLNode *CheckACL(UWORD, STRPTR);
  13. Prototype struct ACLNode *InsertACL(STRPTR);
  14. Prototype VOID RemoveACL(struct ACLNode *);
  15. Prototype VOID ListACL(VOID);
  16. Prototype VOID EditACL(STRPTR);
  17. Prototype BOOL EditACLInfo(struct ACLNode *);
  18. Prototype VOID DeleteACL(STRPTR);
  19. Prototype VOID ListBitNames(VOID);
  20. Prototype BOOL EditBitNames(VOID);
  21.  
  22. extern struct KMSBase *KMSBase;
  23. extern struct LocalConfig *KMS_LC;
  24.  
  25. extern STRPTR PPArg;
  26.  
  27. extern TEXT PathString[LEN_KMSPATH+1];
  28.  
  29. extern UBYTE ShutDown, Plop;
  30.  
  31. /****************************************
  32.  * Zugangsberechtigung auf Brett prüfen *
  33.  ****************************************
  34.  * I: Zeiger auf Brettstruktur          *
  35.  * O: Access (Read/Write/Edit)          *
  36.  ****************************************/
  37.  
  38. /// CheckAccess
  39.  
  40. UBYTE CheckAccess(struct AreaNode *area)
  41.    {
  42.    UBYTE access;
  43.  
  44.    if(KMS_LC->Session.CurrentUser->UserData.Level == 255)
  45.       return AACC_READ|AACC_WRITE|AACC_EDIT;
  46.  
  47.    access = 0;
  48.    if(area->AreaData.ReadLevel <= KMS_LC->Session.CurrentUser->UserData.Level)
  49.       access |= AACC_READ;
  50.    if(area->AreaData.WriteLevel <= KMS_LC->Session.CurrentUser->UserData.Level)
  51.       access |= AACC_WRITE;
  52.    if(area->AreaData.EditLevel <= KMS_LC->Session.CurrentUser->UserData.Level)
  53.       access |= AACC_EDIT;
  54.    if(!access)
  55.       return 0;
  56.  
  57.    if((area->AreaData.AccessBits & KMS_LC->Session.CurrentUser->UserData.AccessBits) != area->AreaData.AccessBits)
  58.       return 0;
  59.  
  60.    struct ACLNode *acl = CheckACL(area->AreaData.ID, KMS_LC->Session.CurrentUser->UserData.Name);
  61.    if(acl)
  62.       return acl->Access;
  63.    else if(area->AreaData.Type & ATYPE_GROUP)
  64.       return 0;
  65.    else
  66.       return access;
  67.    }
  68.  
  69. ///
  70.  
  71. /****************************************
  72.  * Einzelberechtigungs-Prüfung          *
  73.  ****************************************
  74.  * I: Area, Username                    *
  75.  * O: ACL-Struktur                      *
  76.  ****************************************/
  77.  
  78. /// CheckACL
  79.  
  80. struct ACLNode *CheckACL(UWORD id, STRPTR user)
  81.    {
  82.    struct ACLNode *acl;
  83.    UBYTE start = toupper(user[0]) - 'A';
  84.  
  85.    if(start > 25)
  86.       start = 25;
  87.  
  88.    if(KMSBase->ACLIndex[start])
  89.       acl = KMSBase->ACLIndex[start];
  90.    else
  91.       return NULL;
  92.  
  93.    while(acl->Node.mln_Succ)
  94.       {
  95.       if(acl->AreaID == id && !stricmp(acl->UserName, user))
  96.          return acl;
  97.  
  98.       acl = acl->Node.mln_Succ;
  99.       }
  100.  
  101.    return NULL;
  102.    }
  103.  
  104. ///
  105.  
  106. /********************************
  107.  * Neue ACL-Struktur einrichten *
  108.  ********************************
  109.  * I: Username                  *
  110.  * O: struct ACLNode *          *
  111.  ********************************/
  112.  
  113. /// InsertACL
  114.  
  115. struct ACLNode *InsertACL(STRPTR user)
  116.    {
  117.    struct ACLNode *acl, *newacl;
  118.  
  119.    acl = (struct ACLNode *)KMSBase->AccessList.mlh_Head;
  120.  
  121.    while(acl->Node.mln_Succ && stricmp(acl->UserName, user) <= 0)
  122.       acl = (struct ACLNode *)acl->Node.mln_Succ;
  123.  
  124.    if(!(newacl = (struct ACLNode *)AllocMem((ULONG)sizeof(struct ACLNode), MEMF_PUBLIC|MEMF_CLEAR)))
  125.       {
  126.       SystemError("InsertACL", "Out of memory!");
  127.       return NULL;
  128.       }
  129.    strcpy(newacl->UserName, user);
  130.  
  131.    UBYTE idx = toupper(user[0]) - 'A';
  132.    if(idx > 25)
  133.       idx = 25;
  134.  
  135.    if(!KMSBase->ACLIndex[idx])
  136.       KMSBase->ACLIndex[idx] = newacl;
  137.  
  138.    Insert((struct List *)&KMSBase->AccessList, (struct Node *)newacl, (struct Node *)acl->Node.mln_Pred);
  139.  
  140.    return newacl;
  141.    }
  142.  
  143. ///
  144.  
  145. /********************************
  146.  * ACL-Struktur löschen         *
  147.  ********************************
  148.  * I: struct ACLNode *          *
  149.  * O: ---                       *
  150.  ********************************/
  151.  
  152. /// RemoveACL
  153.  
  154. VOID RemoveACL(struct ACLNode *target)
  155.    {
  156.    if(!target)
  157.       return;
  158.  
  159.    KMSBase->Modified |= MODIFIED_ACL;
  160.  
  161.    Remove((struct Node *)target);
  162.  
  163.    FreeMem(target,(ULONG)sizeof(struct ACLNode));
  164.    }
  165.  
  166. ///
  167.  
  168. /********************************
  169.  * ACL-Liste zum akt. Brett     *
  170.  ********************************
  171.  * I: ---                       *
  172.  * O: ---                       *
  173.  ********************************/
  174.  
  175. /// ListACL
  176.  
  177. VOID ListACL(VOID)
  178.    {
  179.    struct ACLNode *acl;
  180.    TEXT acc[4];
  181.    TEXT buff[40];
  182.    UWORD id;
  183.    BOOL titel = TRUE;
  184.    UBYTE stop = 0;
  185.  
  186.    if(!(KMS_LC->Session.CurrentAccess & AACC_EDIT))
  187.       {
  188.       PPArg = KMS_LC->Session.InputBuffer;
  189.       SysMsg(NO_EDIT_ACCESS);
  190.       PPArg = NULL;
  191.       return;
  192.       }
  193.  
  194.    id = KMS_LC->Session.CurrentArea->AreaData.ID;
  195.  
  196.    acl = (struct ACLNode *)KMSBase->AccessList.mlh_Head;
  197.    while(!stop && acl->Node.mln_Succ)
  198.       {
  199.       strcpy(acc, "---");
  200.  
  201.       if(acl->AreaID == id)
  202.          {
  203.          if(titel)
  204.             {
  205.             CreatePath(KMS_LC->Session.CurrentArea);
  206.  
  207.             PPArg = PathString;
  208.             SysMsg(ACLLST_HEAD);
  209.             PPArg = NULL;
  210.  
  211.             KMS_LC->Session.LineCounter = 6;
  212.  
  213.             titel = FALSE;
  214.             }
  215.  
  216.          if(acl->Access & AACC_READ)
  217.             acc[0] = KMSBase->AFlags[AFLAG_READ]; /* 'R'ead */
  218.          if(acl->Access & AACC_WRITE)
  219.             acc[1] = KMSBase->AFlags[AFLAG_WRITE]; /* 'W'rite */
  220.          if(acl->Access & AACC_EDIT)
  221.             acc[2] = KMSBase->AFlags[AFLAG_EDIT]; /* 'E'dit */
  222.  
  223.          sprintf(buff, "%-31.31s %s\n", acl->UserName, acc);
  224.          stop = MsgPrint(buff, 0);
  225.          }
  226.  
  227.       acl = (struct ACLNode *)acl->Node.mln_Succ;
  228.       }
  229.  
  230.    if(titel)
  231.       SysMsg(NO_ACL_FOUND);
  232.    }
  233.  
  234. ///
  235.  
  236. /********************************
  237.  * ACL editieren/neu anlegen    *
  238.  ********************************
  239.  * I: Username                  *
  240.  * O: ---                       *
  241.  ********************************/
  242.  
  243. VOID EditACL(STRPTR user)
  244.    {
  245.    struct ACLNode *acl;
  246.  
  247.    if(!(KMS_LC->Session.CurrentAccess & AACC_EDIT))
  248.       {
  249.       PPArg = KMS_LC->Session.InputBuffer;
  250.       SysMsg(NO_EDIT_ACCESS);
  251.       PPArg = NULL;
  252.       return;
  253.       }
  254.  
  255.    if(acl = CheckACL(KMS_LC->Session.CurrentArea->AreaData.ID, user))
  256.       {
  257.       /* Alten ACL-Eintrag editieren */
  258.  
  259.       if(EditACLInfo(acl))
  260.          {
  261.          KMS_LC->Session.CurrentAccess = CheckAccess(KMS_LC->Session.CurrentArea);
  262.          SysMsg(ACL_MODIFIED);
  263.          }
  264.       }
  265.    else
  266.       {
  267.       if(!UserCheck(user))
  268.          SysMsg(USER_NOT_FOUND);
  269.       else
  270.          {
  271.          if(YNRequest(CREATE_ACL, TRUE))
  272.             {
  273.             /* Neuen ACL-Eintrag anlegen */
  274.  
  275.             if(acl = InsertACL(user))
  276.                {
  277.                acl->AreaID = KMS_LC->Session.CurrentArea->AreaData.ID;
  278.  
  279.                if(EditACLInfo(acl))
  280.                   {
  281.                   KMS_LC->Session.CurrentAccess = CheckAccess(KMS_LC->Session.CurrentArea);
  282.  
  283.                   SysMsg(ACL_CREATED);
  284.                   }
  285.                else
  286.                   RemoveACL(acl);
  287.                }
  288.             else
  289.                SysMsg(ACL_NOT_CREATED);
  290.             }
  291.          }
  292.       }
  293.    }
  294.  
  295. /********************************
  296.  * ACL Eintrag editieren        *
  297.  ********************************
  298.  * I: struct ACLNode *          *
  299.  * O: FALSE: Plop/ShutDown      *
  300.  ********************************/
  301.  
  302. BOOL EditACLInfo(struct ACLNode *target)
  303.    {
  304.    TEXT def[2];
  305.  
  306.    KMSBase->Modified |= MODIFIED_ACL;
  307.  
  308.    if(target->Access & AACC_READ)
  309.       strcpy(def, KMSBase->Yes);
  310.    else
  311.       strcpy(def,KMSBase->No);
  312.    CmdInput(NULL, PROMPT_ACLREAD, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  313.    if(Plop || ShutDown)
  314.       return FALSE;
  315.    if(*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  316.       target->Access |= AACC_READ;
  317.    else
  318.       target->Access &= ~AACC_READ;
  319.  
  320.    if(target->Access & AACC_WRITE)
  321.       strcpy(def, KMSBase->Yes);
  322.    else
  323.       strcpy(def,KMSBase->No);
  324.    CmdInput(NULL, PROMPT_ACLWRITE, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  325.    if(Plop || ShutDown)
  326.       return FALSE;
  327.    if(*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  328.       target->Access |= AACC_WRITE;
  329.    else
  330.       target->Access &= ~AACC_WRITE;
  331.  
  332.    if(target->Access & AACC_EDIT)
  333.       strcpy(def,KMSBase->Yes);
  334.    else
  335.       strcpy(def,KMSBase->No);
  336.    CmdInput(NULL, PROMPT_ACLEDIT, KMSBase->YNText, def, 1, INF_PROMPT|INF_UPCASE);
  337.    if(Plop || ShutDown)
  338.       return FALSE;
  339.    if(*KMS_LC->Session.InputBuffer == KMSBase->YNText[YES])
  340.       target->Access |= AACC_EDIT;
  341.    else
  342.       target->Access &= ~AACC_EDIT;
  343.  
  344.    return TRUE;
  345.    }
  346.  
  347. /********************************
  348.  * ACL löschen                  *
  349.  ********************************
  350.  * I: Username                  *
  351.  * O: ---                       *
  352.  ********************************/
  353.  
  354. VOID DeleteACL(STRPTR user)
  355.    {
  356.    struct ACLNode *acl;
  357.  
  358.    if(!(KMS_LC->Session.CurrentAccess & AACC_EDIT))
  359.       {
  360.       PPArg = KMS_LC->Session.InputBuffer;
  361.       SysMsg(NO_EDIT_ACCESS);
  362.       PPArg = NULL;
  363.       return;
  364.       }
  365.  
  366.    if(acl = CheckACL(KMS_LC->Session.CurrentArea->AreaData.ID, user))
  367.       {
  368.       if(YNRequest(DELETE_ACL, FALSE))
  369.          {
  370.          RemoveACL(acl);
  371.  
  372.          SysMsg(ACL_DELETED);
  373.          }
  374.       }
  375.    else
  376.       SysMsg(ACL_NOT_FOUND);
  377.    }
  378.  
  379. /********************************
  380.  * Zugriffsbit-Namen auflisten  *
  381.  ********************************
  382.  * I: ---                       *
  383.  * O: ---                       *
  384.  ********************************/
  385.  
  386. VOID ListBitNames(VOID)
  387.    {
  388.    UBYTE n;
  389.    TEXT buff[81];
  390.  
  391.    SysMsg(BITLST_HEAD);
  392.  
  393.    for(n = 0; n < 32; n += 4)
  394.       {
  395.       sprintf(buff, "%2d: %-15s %2d: %-15s %2d: %-15s %2d: %-15s", n+1, KMSBase->AccBitNames[n], n+2, KMSBase->AccBitNames[n+1], n+3, KMSBase->AccBitNames[n+2], n+4, KMSBase->AccBitNames[n+3]);
  396.       Print(buff, 0);
  397.       }
  398.  
  399.    Print(NULL, 0);
  400.    }
  401.  
  402. /********************************
  403.  * Zugriffsbit-Namen ändern     *
  404.  ********************************
  405.  * I: ---                       *
  406.  * O: FALSE: Plop/ShutDown      *
  407.  ********************************/
  408.  
  409. BOOL EditBitNames(VOID)
  410.    {
  411.    LONG result = 1;
  412.  
  413.    while(result > 0 && result < 33)
  414.       {
  415.       ListBitNames();
  416.  
  417.       result = CmdInput(NULL, PROMPT_BITNUM, NULL, NULL, 2, INF_PROMPT|INF_NUMERIC);
  418.       if(Plop || ShutDown)
  419.          return FALSE;
  420.  
  421.       if(result > 0 && result < 33)
  422.          {
  423.          CmdInput(NULL, PROMPT_BITNAME, NULL, KMSBase->AccBitNames[result-1], LEN_ACCBITNAME, INF_PROMPT|INF_UPCASE|INF_DEFBUF);
  424.          if(Plop || ShutDown)
  425.             return FALSE;
  426.          strcpy(KMSBase->AccBitNames[result-1], KMS_LC->Session.InputBuffer);
  427.          }
  428.       else if(result > 32)
  429.          SysMsg(INVALID_BITNUM);
  430.       }
  431.  
  432.    return TRUE;
  433.    }
  434.  
  435.